//geg das Array das alle gegner objekte enthält
geg = [];
function gegner(x, y, z){
	//die Grund inizialsierungen die für die Mesh gebraucht werden
	this.gegnerGeo = new t.BoxGeometry( 100, 100, 100);
	//new t.MeshLambertMaterial({map: t.ImageUtils.loadTexture('images/boden_1.jpg')})
	this.gegnerMat = new t.MeshLambertMaterial({map: t.ImageUtils.loadTexture('images/gegner.jpg')})				//color: 0x221111})
	this.gegner = new t.Mesh(this.gegnerGeo, this.gegnerMat);
	
	var coreMat = new t.MeshBasicMaterial({color: 0xffffff});
	var coreGeo = new t.SphereGeometry(55, 12, 12);
	
	var core = new t.Mesh(coreGeo, coreMat);
	this.gegner.add(core);
	
	this.hitPoints = 100;
	this.dm = -10;
	
	this.xPo = x;
	this.yPo = y;
	this.zPo = z;
	
	this.aggro = 0;
	this.moveDirection = new t.Ray;
	this.moveTarget = new t.Vector3;
	this.moveEnabled = 1
	this.sichtkontakt = 0;
	
	this.rBox = new t.Vector3((850),(850),(850));
	
	
	this.cooldown = date.getTime();
	
	this.gegner.position.set(x, y, z);
	
	//das erstellen und übergeben der Boundingbox
	this.gegner.geometry.computeBoundingBox();
	this.gegner.geometry.boundingBox = new t.Box3().setFromObject(this.gegner);
	this.reichweite = new t.Box3();
	
	updateReichweite(this);
	
	console.log(this, this.gegner.children[0]);
	//das Objekt Gegner wird in das Array hinzugefügt
	geg.push(this);
	//die Mesh gegner wird in die scene hinzu gefügt
	scene.add(this.gegner);
}

//updateReichweite aktuallisert die angrifsreichweite des Gegners
//dies wird gebraucht um die angrifsreichweite aktuell zu halten nach
//z.b bewegungen
function updateReichweite(gegner){
	var min = new t.Vector3(
		(gegner.gegner.position.x - gegner.rBox.x),
		(gegner.gegner.position.y - gegner.rBox.y),
		(gegner.gegner.position.z - gegner.rBox.z)
		);
		
	var max = new t.Vector3(
		(gegner.gegner.position.x + gegner.rBox.x),
		(gegner.gegner.position.y + gegner.rBox.y),
		(gegner.gegner.position.z + gegner.rBox.z)
		);
	
	gegner.reichweite.set(min, max);
}


//Gegner Move lasst sich die Gegner bewegen in der welt
//dabei muss allerdings einerseits die gegner.aggro ==1 sein also wenn sich
//der spieler in der Reichweite befindet, zudem darf der gegner kein sichtkontakt haben
//dieser wert wird in der gegnerAttack berechnet
//d
function gegnerMove(speed){
	movement = speed / 2;
	for(var i = 0; i < geg.length; i++){
		gegner = geg[i];
		if(gegner.aggro == 1 && gegner.sichtkontakt == 0){
		
			if(gegner.moveEnabled != 0){
				checkMoveX(gegner);
			}

			if(gegner.moveEnabled != 0){
				checkMoveZ(gegner);
			}

			//hier wird überprüft ob der 2D punkt in einem Radius von 100 um 
			//gegner.moveTarget befindet falls ja beendet er die bewegungen
			//dies wird gebraucht um korrekt die bewegung abzubrechen
			var checkPoX = gegner.gegner.position.x - gegner.moveTarget.x;
			var checkPoZ = gegner.gegner.position.z - gegner.moveTarget.z;
			if(	((checkPoX * checkPoX) + (checkPoZ * checkPoZ)) > 100*100 ){
			//console.log(gegner.gegner.position, gegner.moveTarget, gegner.moveDirection);
				gegner.gegner.translateX(movement * gegner.moveDirection.direction.x);
				gegner.gegner.translateY(movement * gegner.moveDirection.direction.y);
				gegner.gegner.translateZ(movement * gegner.moveDirection.direction.z);
				gegner.gegner.geometry.boundingBox = new t.Box3().setFromObject(gegner.gegner);
				//console.log((checkPoX * checkPoX), 100*100);
				updateReichweite(gegner);
			}
			else{
				gegner.moveEnabled = 1;
			}
		}
	}
}
//checkMoveX und Z überprüft ob sich der Gegner dem Spieler anzunähern
//allerdings nur dann wenn auch keine Wall dazwischen ist
function checkMoveX(gegner){
	var start = new t.Vector3(gegner.gegner.position.x, gegner.gegner.position.y, gegner.gegner.position.z);
	var end = new t.Vector3(cam.position.x, gegner.gegner.position.y, gegner.gegner.position.z);
	var fubar = new t.Vector3(cam.position.x, gegner.gegner.position.y, gegner.gegner.position.z);
	//console.log(end, fubar);
	var startS = getMapSector(start);
	//console.log(startS);
	var endS = getMapSector(end);
	//console.log(endS);
	if(startS != endS){
		var strecke = new t.Line3(start, end);
		var test = new t.Vector3(0,0,0);
		var p = 0;
		for(var f = 0; f < 1 ; f = f + 0.1){
			strecke.at(f, test);
				if(checkWallCollision(test)){
					p = 1;
				}
		}
		if(p == 0){
			gegner.moveTarget = end;
			//console.log(gegner.moveTarget);
			gegner.moveEnabled = 0;		
			gegner.moveDirection.set(
				start,
				fubar.sub(start).normalize()
			);
		}
	}
}


function checkMoveZ(gegner){
	var start = new t.Vector3(gegner.gegner.position.x, gegner.gegner.position.y, gegner.gegner.position.z);
	var end = new t.Vector3(gegner.gegner.position.x, gegner.gegner.position.y, cam.position.z);
	var fubar = new t.Vector3(gegner.gegner.position.x, gegner.gegner.position.y, cam.position.z);
	var startS = getMapSector(start);
	var endS = getMapSector(end);
	if(startS != endS){
		var strecke = new t.Line3(start, end);
		var test = new t.Vector3(0,0,0);
		var p = 0;
		for(var f = 0; f < 1 ; f = f + 0.1){
			strecke.at(f, test);
				if(checkWallCollision(test)){
					p = 1;
				}
		}
		if(p == 0){
			gegner.moveTarget = end;
			console.log(gegner.moveTarget);
			gegner.moveEnabled = 0;		
			gegner.moveDirection.set(
				start,
				fubar.sub(start).normalize()
			);
		 }
	}
}
//gegnerAttack überprüft ob der spieler in reichweite und er in sichtkontakt ist
//ist er in sichtkontakt richtet er sich nach dem spieler aus, verliert er diesen
//richtet er sich wieder wie ürsprünglich aus
function gegnerAttack(){
	for(var i = 0; i < geg.length; i++){
		var ich = geg[i];
		var date = new Date();
		
			if(ich.sichtkontakt == 1){
				ich.gegner.lookAt(cam.position);
			}else{
				ich.gegner.lookAt(ich.gegner.position);
			}
			//console.log(ich);
			
			var timeCheck = date.getTime();
			if(ich.cooldown+1000 <= timeCheck){
				ich.cooldown = date.getTime();
				if(	ich.reichweite.min.x < cam.position.x && ich.reichweite.max.x > cam.position.x &&
					ich.reichweite.min.y < cam.position.y && ich.reichweite.max.y > cam.position.y &&
					ich.reichweite.min.z < cam.position.z && ich.reichweite.max.z > cam.position.z){
					//console.log("peng hab dich");
					
					//check ob eine wall dazwischen ist
					
					var vectorEnd = new t.Vector3(cam.position.x, cam.position.y, cam.position.z);
					var vectorStart = new t.Vector3(ich.gegner.position.x, ich.gegner.position.y, ich.gegner.position.z);
					var vectorTest = new t.Vector3();
					var test = new t.Line3(vectorStart, vectorEnd);
					var p = 0;
					for(j = 0; j <= 1; j = j+0.1){
						test.at(j, vectorTest);
						
						
						if(checkWallCollision(vectorTest) > 0){
							p = 1;
						}
						var vectorTest = new t.Vector3();
					}
					if(p == 0){
						ich.gegner.lookAt(cam.position);
						createBullet(ich);
						ich.aggro = 1;
						ich.sichtkontakt = 1;
					}
					else{
						ich.sichtkontakt = 0;
						ich.gegner.lookAt(ich.gegner.position);
						//console.log("wo bist du hin?");
					}
				}
			}
		
	}
}

minen = [];
function mines(x,y,z){
	this.pX=x;
	this.pY=y;
	this.pZ=z;
	
	this.looked = 0;
	this.targedRay = new t.Ray();

	var vMin = new t.Vector3((x-1000),(y-500),(z-1000));
	var vMax = new t.Vector3((x+1000),(y+500),(z+1000));

	this.reichweite = new t.Box3(vMin, vMax);

	this.mineGeo = new t.BoxGeometry( 50, 50, 50);
	this.mineMat = new t.MeshBasicMaterial({color: 0x006600});
	
	this.mine = new t.Mesh(this.mineGeo, this.mineMat);
	this.mine.position.set(x, y, z);
	
	this.dm = -30;
		
	this.mine.geometry.computeBoundingBox();
	this.mine.geometry.boundingBox = new t.Box3().setFromObject(this.mine);
	console.log(this.mine.geometry.boundingBox);

	console.log(this);
	scene.add(this.mine);
	minen.push(this);
}

//updateMines ist ähnlich gegnerAttack es wird überprüft ob sich der spieler in reichweite
//befindet und ob direkten sicht kontatk besteht falls ja bewegt sich die Mine ununter brochen
//auf den spieler zu und zieht ihm bei berührung schaden zu
function updateMines(speed){
	for(var i = 0; i < minen.length; i++){
		var mine = minen[i];
		
		if (mine.looked == 0){
			if(	mine.reichweite.min.x < cam.position.x && mine.reichweite.max.x > cam.position.x &&
				mine.reichweite.min.y < cam.position.y && mine.reichweite.max.y > cam.position.y &&
				mine.reichweite.min.z < cam.position.z && mine.reichweite.max.z > cam.position.z){
				
				//check ob eine wall dazwischen ist
				
				var vectorEnd = new t.Vector3(cam.position.x, cam.position.y, cam.position.z);
				var vectorStart = new t.Vector3(mine.mine.position.x, mine.mine.position.y, mine.mine.position.z);
				var vectorTest = new t.Vector3
				var test = new t.Line3(vectorStart, vectorEnd);
				var p = 0;
				for(j = 0; j <= 1; j = j+0.1){
					test.at(j, vectorTest);
					
					
					if(checkWallCollision(vectorTest) > 0){
						p = 1;
					}
					var vectorTest = new t.Vector3
				}
				if(p == 0){
					
					//console.log("looked on");
					mine.looked = 1;
					var vector = new t.Vector3(cam.position.x, cam.position.y, cam.position.z);
					//console.log(vector,mine.mine.position, mine.targedRay);
					mine.targedRay.set(
						mine.mine.position,
						vector.sub(mine.mine.position).normalize()
					);
				}
			}
		}
		 else{
			var vector = new t.Vector3(cam.position.x, cam.position.y, cam.position.z);
			mine.targedRay.set(
				mine.mine.position,
				vector.sub(mine.mine.position).normalize()
			);
		}
		if (checkWallCollision(mine.mine.position)) {
			minen.splice(i, 1);
			scene.remove(mine.mine);
		}
		mine.mine.translateX(speed * mine.targedRay.direction.x);
		mine.mine.translateY(speed * mine.targedRay.direction.y);
		mine.mine.translateZ(speed * mine.targedRay.direction.z);
		mine.mine.geometry.boundingBox = new t.Box3().setFromObject(mine.mine);
		
		if(	mine.mine.geometry.boundingBox.min.x < cam.position.x && mine.mine.geometry.boundingBox.max.x > cam.position.x &&
			mine.mine.geometry.boundingBox.min.y < cam.position.y && mine.mine.geometry.boundingBox.max.y > cam.position.y &&
			mine.mine.geometry.boundingBox.min.z < cam.position.z && mine.mine.geometry.boundingBox.max.z > cam.position.z){
				console.log("boom");
				hpChange(mine.dm);
				minen.splice(i, 1);
				scene.remove(mine.mine);		
		}	
	}

}

bosse=[];
//erstellt einen Boss wobei der boss einen core enthält und der
//core die armor parts als children beinhaltet
function boss(x,y,z){
	this.xPo = x;
	this.yPo = y;
	this.zPo = z;
	
	var min = new t.Vector3(x-25,y-25,z-25);
	var max = new t.Vector3(x+25,y+25,z+25);

	var coreMaterial = new t.MeshBasicMaterial({color: 0xffffff});
	var coreGeo = new t.SphereGeometry(60, 8, 8);
	
	this.core = new t.Mesh(coreGeo, coreMaterial)
	this.core.position.set(x,y,z);
	this.core.geometry.computeBoundingBox();
	this.core.geometry.boundingBox = new t.Box3(min, max);
	scene.add(this.core);

	var armorGeo = new t.BoxGeometry( 60, 60, 60);
	//var armorMat = new t.MeshBasicMaterial({color: 0x221111});
	var armorMat = new t.MeshLambertMaterial({map: t.ImageUtils.loadTexture('images/boden_1.jpg')});
	var armor0 = new t.Mesh(armorGeo, armorMat);
	this.core.add(armor0);

	var armor1 = new t.Mesh(armorGeo, armorMat);
	this.core.add(armor1);
	
	var armor2 = new t.Mesh(armorGeo, armorMat);
	this.core.add(armor2);
	
	var armor3 = new t.Mesh(armorGeo, armorMat);
	this.core.add(armor3);
	
	var armor4 = new t.Mesh(armorGeo, armorMat);
	this.core.add(armor4);
	
	var armor5 = new t.Mesh(armorGeo, armorMat);
	this.core.add(armor5);
	
	var armor6 = new t.Mesh(armorGeo, armorMat);
	this.core.add(armor6);
	
	var armor7 = new t.Mesh(armorGeo, armorMat);
	this.core.add(armor7);
	
	for(var i = 0; i <= 7; i++){
		var u = 40;
		setArmor = this.core.children[i];
		console.log(setArmor, i);
		switch(i){
			case 0:
				setArmor.position.set((- u),(- u),(- u));
				setArmor.geometry.computeBoundingBox();
				setArmor.geometry.boundingBox = new t.Box3().setFromObject(setArmor);
			break;
			
			case 1:
				setArmor.position.set((+ u),(- u),(- u));
				setArmor.geometry.computeBoundingBox();
				setArmor.geometry.boundingBox = new t.Box3().setFromObject(setArmor);
			break;
			
			case 2:
				setArmor.position.set((+ u),(- u),(+ u));
				setArmor.geometry.computeBoundingBox();
				setArmor.geometry.boundingBox = new t.Box3().setFromObject(setArmor);
			break;
			
			case 3:
				setArmor.position.set((- u),(- u),(+ u));
				setArmor.geometry.computeBoundingBox();
				setArmor.geometry.boundingBox = new t.Box3().setFromObject(setArmor);
			break;
			
			case 4:
				setArmor.position.set((- u),(+ u),(- u));
				setArmor.geometry.computeBoundingBox();
				setArmor.geometry.boundingBox = new t.Box3().setFromObject(setArmor);
			break;
			
			case 5:
				setArmor.position.set((+ u),(+ u),(- u));
				setArmor.geometry.computeBoundingBox();
				setArmor.geometry.boundingBox = new t.Box3().setFromObject(setArmor);
			break;
			
			case 6:
				setArmor.position.set((+ u),(+ u),(+ u));
				setArmor.geometry.computeBoundingBox();
				setArmor.geometry.boundingBox = new t.Box3().setFromObject(setArmor);
			break;
			
			case 7:
				setArmor.position.set((- u),(+ u),(+ u));
				setArmor.geometry.computeBoundingBox();
				setArmor.geometry.boundingBox = new t.Box3().setFromObject(setArmor);
			break; 	
		}   
	}
	this.core.add(new t.PointLight(0xff0000, 10 ,500));
	var minR = new t.Vector3(x-1000,y-1000,z-1000);
	var maxR = new t.Vector3(x+1000,y+1000,z+1000);
	this.reichweite = new t.Box3(minR, maxR);
	this.sichtkontakt = 0;
	this.dm = -10;
	this.hitPoints = 130;
	this.cooldown = date.getTime();
	console.log(this);
	bosse.push(this);
}


//hier wird die rotation des Bosses durchgefürt
//hierbei muss nur der core rotiert werden da die Armorparts
//desen children sind
function rotBoss(){
	axis = new t.Vector3(1,0,0)
	boss = bosse[0];
	var deg = 1;
	var rad = deg * (Math.PI/180);
	boss.core.rotateOnAxis (axis, rad);
	
	for(var i = 0; i <= 7; i++){
		setArmor = boss.core.children[i];
		setArmor.geometry.boundingBox = new t.Box3().setFromObject(setArmor);
		//console.log(setArmor.geometry.boundingBox,i);
	}
}

//bossAttack ähnlich wie gegnerAttack allerdings mit verkürter cooldown zeit
//um ihn schwieriger zu gestalten
function bossAttack(){
	var ich = bosse[0];
	var date = new Date();;

		//console.log(ich);
		
		var timeCheck = date.getTime();
		if(ich.cooldown+500 <= timeCheck){
			ich.cooldown = date.getTime();
			if(	ich.reichweite.min.x < cam.position.x && ich.reichweite.max.x > cam.position.x &&
				ich.reichweite.min.y < cam.position.y && ich.reichweite.max.y > cam.position.y &&
				ich.reichweite.min.z < cam.position.z && ich.reichweite.max.z > cam.position.z){
				
				//check ob eine wall dazwischen ist
				
				var vectorEnd = new t.Vector3(cam.position.x, cam.position.y, cam.position.z);
				var vectorStart = new t.Vector3(ich.core.position.x, ich.core.position.y, ich.core.position.z);
				var vectorTest = new t.Vector3();
				var test = new t.Line3(vectorStart, vectorEnd);
				var p = 0;
				for(j = 0; j <= 1; j = j+0.1){
					test.at(j, vectorTest);
					
					
					if(checkWallCollision(vectorTest) > 0){
						p = 1;
					}
					var vectorTest = new t.Vector3();
				}
				if(p == 0){
					createBullet(ich);
					ich.aggro = 1;
					ich.sichtkontakt = 1;
				}
				else{
					ich.sichtkontakt = 0;
					//console.log("wo bist du hin?");
				}
			}
		}
	}



